import { defineStore } from 'pinia'
import axios from 'axios'
import { usersApi, locationsApi } from '../utils/apiService'
import { usePermissionStore } from './permission'
import { ref, computed } from 'vue'
import { messageHelper } from '../utils/messageHelper'

// 获取设备信息和当前时间的辅助函数
function getDeviceInfo() {
    const userAgent = navigator.userAgent
    let deviceInfo = '未知设备'

    if (/Windows/.test(userAgent)) {
        deviceInfo = 'Windows设备'
    } else if (/Macintosh/.test(userAgent)) {
        deviceInfo = 'Mac设备'
    } else if (/iPhone/.test(userAgent)) {
        deviceInfo = 'iPhone设备'
    } else if (/iPad/.test(userAgent)) {
        deviceInfo = 'iPad设备'
    } else if (/Android/.test(userAgent)) {
        deviceInfo = 'Android设备'
    }

    return deviceInfo
}

function getCurrentTime() {
    const now = new Date()
    return now.toLocaleString('zh-CN', {
        year: 'numeric',
        month: '2-digit',
        day: '2-digit',
        hour: '2-digit',
        minute: '2-digit',
        second: '2-digit'
    })
}

export const useUserStore = defineStore('user', {
    state: () => ({
        user: null,
        token: localStorage.getItem('token') || null,
        tokenType: localStorage.getItem('tokenType') || 'Bearer',
        isLoggedIn: !!localStorage.getItem('token')
    }),

    getters: {
        getUser: (state) => state.user,
        isAuthenticated: (state) => state.isLoggedIn
    },

    actions: {
        // 获取当前用户信息
        async getCurrentUser() {
            try {
                // 检查是否有token
                if (!this.token) {
                    console.error('没有token，无法获取用户信息')
                    return false
                }

                // 尝试从当前store中获取用户ID
                let userId = this.user?.id;

                // 如果store中没有userId，尝试从localStorage中获取
                if (!userId) {
                    try {
                        const userJson = localStorage.getItem('user');
                        if (userJson && userJson !== 'undefined') {
                            const userDataFromStorage = JSON.parse(userJson);
                            if (userDataFromStorage && userDataFromStorage.id) {
                                userId = userDataFromStorage.id;
                                // 同时更新store中的user对象
                                this.user = userDataFromStorage;
                                console.log('从localStorage恢复了user对象:', this.user);
                            }
                        }
                    } catch (e) {
                        console.error('从localStorage恢复用户信息失败:', e);
                        // 清理可能损坏的localStorage user数据
                        localStorage.removeItem('user');
                    }
                }

                // 如果仍然没有userId，则表示无法确定用户，请求可能失败或获取的是通用信息
                if (!userId) {
                    console.warn('无法从store或localStorage获取有效的userId，继续尝试调用API，可能依赖后端处理无userId的情况');
                    // 此时 userId 会是 undefined，后端需要能处理这种情况，或者前端应阻止此调用
                }

                // 调用API获取当前用户信息
                const response = await usersApi.getCurrentUser(userId); // userId 可能为 undefined
                console.log('获取当前用户信息响应:', response)

                // 确保获取到有效的用户数据
                if (response && response.code === 200 && response.data && typeof response.data === 'object') {
                    this.user = response.data
                    this.isLoggedIn = true

                    // 只有在 user 有效时才保存到 localStorage
                    localStorage.setItem('user', JSON.stringify(this.user))
                    console.log('当前用户信息已更新并保存到localStorage')

                    // 获取用户位置权限
                    await this.loadUserLocationPermissions()

                    return true
                } else {
                    console.error('从API获取的用户数据无效', response)
                    // 清理可能存在的无效数据
                    this.user = null
                    this.isLoggedIn = false
                    localStorage.removeItem('user')
                    return false
                }
            } catch (error) {
                console.error('获取当前用户信息失败:', error)
                // 清理可能存在的无效数据
                this.user = null
                this.isLoggedIn = false
                localStorage.removeItem('user')
                return false
            }
        },

        async login(username, password) {
            try {
                // 使用API服务调用真实的后端登录接口
                const response = await usersApi.login({ username, password })

                console.log('登录响应完整数据:', response)

                // 处理嵌套的响应结构
                // 检查返回的数据结构是否包含data对象
                const responseData = response.data || response;

                // 检查token是否存在，以及其在响应中的位置
                if (!responseData.token) {
                    console.error('响应中没有找到标准token字段:', responseData)
                    // 尝试从其他可能的位置获取token
                    this.token = responseData.accessToken || responseData.access_token || null
                    console.log('尝试从其他位置获取的token:', this.token)
                } else {
                    this.token = responseData.token
                    console.log('找到标准token字段:', this.token)
                }

                // 检查tokenType
                if (responseData.tokenType) {
                    this.tokenType = responseData.tokenType
                    console.log('找到tokenType:', this.tokenType)
                } else if (responseData.token_type) {
                    this.tokenType = responseData.token_type
                    console.log('找到token_type:', this.tokenType)
                } else {
                    this.tokenType = 'Bearer'
                    console.log('未找到tokenType，使用默认值:', this.tokenType)
                }

                // 检查用户对象
                if (responseData.user && typeof responseData.user === 'object') {
                    this.user = responseData.user
                    console.log('登录操作：找到用户对象并赋值给 this.user:', JSON.parse(JSON.stringify(this.user)))
                } else {
                    this.user = null // 如果响应中没有有效的user对象，则设为null
                    console.warn('登录操作：登录响应中未找到有效的用户对象或responseData.user不是对象。responseData.user:', responseData.user)
                }

                this.isLoggedIn = !!this.token

                if (this.token) {
                    localStorage.setItem('token', this.token)
                    localStorage.setItem('tokenType', this.tokenType)
                    // 只有在 user 有效时才保存到 localStorage
                    console.log('登录操作：检查 this.user 是否有效以便调用 loadUserLocationPermissions。this.user:', JSON.parse(JSON.stringify(this.user || null)))
                    if (this.user && this.user.id) { // 确保 this.user.id 也存在
                        localStorage.setItem('user', JSON.stringify(this.user))
                        console.log('登录操作：user已保存到localStorage，准备调用 loadUserLocationPermissions')

                        // 记录登录消息和活动
                        const deviceInfo = getDeviceInfo()
                        const loginTime = getCurrentTime()

                        // 创建登录通知
                        await messageHelper.createLoginNotification(this.user, deviceInfo, loginTime)

                        // 加载用户位置权限
                        await this.loadUserLocationPermissions()
                    } else {
                        localStorage.removeItem('user') // 移除可能存在的无效值
                        console.warn('登录操作：用户信息无效 (this.user 或 this.user.id 不存在)，已从localStorage移除，并跳过 loadUserLocationPermissions。this.user:', JSON.parse(JSON.stringify(this.user || null)))
                    }
                    return true
                } else {
                    console.error('无法获取有效token，登录失败')
                    localStorage.removeItem('user') // 登录失败也移除旧的用户信息
                    throw new Error('登录响应中没有有效的token')
                }
            } catch (error) {
                console.error('登录失败:', error)
                // 登录失败，清理状态和存储
                this.user = null
                this.token = null
                this.tokenType = 'Bearer'
                this.isLoggedIn = false
                localStorage.removeItem('token')
                localStorage.removeItem('tokenType')
                localStorage.removeItem('user')
                throw error // 确保错误总是被抛出
            }
        },

        async register(userData) {
            try {
                // 使用API服务调用真实的后端注册接口
                const response = await usersApi.register(userData)
                return true
            } catch (error) {
                console.error('注册失败:', error)
                // 将错误向上传递
                throw error
            }
        },

        async logout() {
            try {
                // 保存当前用户信息，用于记录日志
                const currentUser = this.user ? { ...this.user } : null;
                const logoutTime = getCurrentTime();

                console.log('用户登出：跳过API调用，仅清理本地状态和记录活动。');

                // 记录登出消息和活动 - 在resetState之前执行，并确保传递必要的ID和名称
                if (currentUser && currentUser.id) { // 确保currentUser 和 id 存在
                    await messageHelper.createLogoutNotification(
                        { id: currentUser.id, name: currentUser.name || currentUser.username },
                        logoutTime
                    );
                    // await messageHelper.recordUserLogout(
                    //     { id: currentUser.id, name: currentUser.name || currentUser.username }
                    // );
                } else {
                    console.warn('登出时无法获取当前用户信息，无法记录登出消息/活动');
                }

                // 清理状态
                this.resetState();
                return true;
            } catch (error) {
                console.error('登出过程中发生错误 (可能在记录消息/活动时):', error);
                this.resetState(); // 即使发生错误，也确保清理本地状态
                return false;
            }
        },

        resetState() {
            // 清理状态
            this.user = null
            this.token = null
            this.tokenType = 'Bearer'
            this.isLoggedIn = false
            this.userLocations = []
            this.userPermissions = {}

            // 清理localStorage
            localStorage.removeItem('token')
            localStorage.removeItem('tokenType')
            localStorage.removeItem('user')
        },

        // 加载用户位置权限的方法
        async loadUserLocationPermissions() {
            if (!this.user || !this.user.id) {
                console.warn('没有用户信息，无法获取位置权限')
                return
            }

            try {
                console.log('开始获取用户位置权限，用户ID:', this.user.id)
                const permissionStore = usePermissionStore()
                const response = await locationsApi.getUserLocationPermissions(this.user.id)

                if (response && response.code === 200 && response.data) {
                    console.log('加载到用户位置权限数据:', response.data)
                    permissionStore.setUserLocationPermissions(response.data)
                    return true
                } else {
                    console.warn('获取用户位置权限失败:', response)
                    return false
                }
            } catch (error) {
                console.error('加载用户位置权限出错:', error)
                return false
            }
        }
    }
}) 